package com.boot.util;

import cn.hutool.core.util.ReflectUtil;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 转换工具
 */
@Slf4j
public class ConvertUtil {

    /**
     * Map转Class
     *
     * @param map   需转换的Map
     * @param clazz 转换后的类
     * @return 类
     */
    public static <T> T mapToClass(Map<String, Object> map, Class<T> clazz) {
        T instance = null;
        try {
            instance = clazz.getDeclaredConstructor().newInstance();
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();
                Field field = ReflectUtil.getField(clazz, key);
                ReflectUtil.setFieldValue(instance, field, value);
            }
        } catch (Exception ignored) {
        }
        return instance;
    }

    /**
     * Object转List
     *
     * @param object 对象
     * @return 列表
     */
    public static List<Object> objectToList(Object object) {
        if (object instanceof List<?>) {
            return new ArrayList<>((List<?>) object);
        }
        return null;
    }

    /**
     * 将具有父子关系的列表转换为树形结构
     *
     * @param list      包含父子关系的列表数据
     * @param idField   标识节点唯一ID的字段名
     * @param parentField 标识父节点ID的字段名
     * @param childrenField 存放子节点列表的字段名
     * @param rootValue 根节点的父节点值（通常为null或特定值如0）
     * @return 树形结构列表
     */
    public static <T> List<T> listToTree(List<T> list, String idField, String parentField, String childrenField, Object rootValue) {
        List<T> tree = new ArrayList<>();
        try {
            for (T item : list) {
                Object parentId = ReflectUtil.getFieldValue(item, parentField);
                if ((parentId == null && rootValue == null) || (parentId != null && parentId.equals(rootValue))) {
                    // 找到根节点
                    tree.add(item);
                }
            }

            // 递归构建每个根节点的子树
            for (T root : tree) {
                buildTree(list, root, idField, parentField, childrenField);
            }
        } catch (Exception e) {
            log.error("listToTree error:", e);
        }
        return tree;
    }

    /**
     * 递归构建树形结构
     *
     * @param list          所有节点列表
     * @param parent        当前父节点
     * @param idField       标识节点唯一ID的字段名
     * @param parentField   标识父节点ID的字段名
     * @param childrenField 存放子节点列表的字段名
     */
    private static <T> void buildTree(List<T> list, T parent, String idField, String parentField, String childrenField) {
        try {
            Object parentId = ReflectUtil.getFieldValue(parent, idField);
            List<T> children = new ArrayList<>();

            for (T item : list) {
                Object itemParentId = ReflectUtil.getFieldValue(item, parentField);
                if (parentId != null && parentId.equals(itemParentId)) {
                    children.add(item);
                }
            }

            // 设置子节点
            ReflectUtil.setFieldValue(parent, childrenField, children);

            // 递归构建每个子节点的子树
            for (T child : children) {
                buildTree(list, child, idField, parentField, childrenField);
            }
        } catch (Exception e) {
            log.error("buildTree error:", e);
        }
    }


}
